package com.gupaoedu.curator;

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.locks.InterProcessLock;
import org.apache.curator.framework.recipes.locks.InterProcessMutex;
import org.apache.curator.retry.ExponentialBackoffRetry;


/**
 *  这段代码：10个线程去同时竞争锁，
 *   一个线程获得锁之后，其他的9个会阻塞在那里，直到第一个获得锁的线程调用lock.release();  释放了之后
 *   后续被挂起的线程才有机会去抢占锁
 *
 *
 *  观察一下locks下的10个节点。 其中最小的0 这个节点会先获得锁。然后线程释放了之后，后面的线程又继续获得锁，同时0这个节点就被删除了
 *  然后就是1这个节点会被删除，按照顺序来
 */
public class LockDemo {


    private static String CONNECTION_STR="192.168.13.102:2181,192.168.13.103:2181,192.168.13.104:2181";

    public static void main(String[] args) {
        CuratorFramework curatorFramework = CuratorFrameworkFactory.builder().
                connectString(CONNECTION_STR).sessionTimeoutMs(50000000).
                retryPolicy(new ExponentialBackoffRetry(1000, 3)).build();
        curatorFramework.start();

        //这个path就是锁节点， 可以理解为是一个命名空间。
        //后续所有的进程如果要去争抢锁，就会在locks节点下 去创建临时有序节点。
        final InterProcessMutex lock=new InterProcessMutex(curatorFramework,"/locks");

        for(int i=0;i<10;i++){
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"->尝试竞争锁");
                try {
                    lock.acquire(); //阻塞竞争锁
                    //执行到下一句，说明有个人拿到了锁。
                    System.out.println(Thread.currentThread().getName()+"->成功获得了锁");
                } catch (Exception e) {
                    e.printStackTrace();
                }
                try {
                    Thread.sleep(400000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    try {
                        lock.release(); //释放锁
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            },"Thread-"+i).start();
        }
    }



}
